home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pycentral-data / pyversions.pyc (.txt) < prev   
Python Compiled Bytecode  |  2009-10-28  |  14KB  |  523 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import re
  6. import string
  7. import sys
  8.  
  9. try:
  10.     SetType = set
  11. except NameError:
  12.     import sets
  13.     SetType = sets.Set
  14.     set = sets.Set
  15.  
  16.  
  17. class PyCentralEmptyValueError(ValueError):
  18.     '''Python Central Value Error'''
  19.     pass
  20.  
  21. _defaults = None
  22.  
  23. def read_default(name = None):
  24.     global _defaults
  25.     SafeConfigParser = SafeConfigParser
  26.     NoOptionError = NoOptionError
  27.     import ConfigParser
  28.     if not _defaults:
  29.         if os.path.exists('/usr/share/python/debian_defaults'):
  30.             config = SafeConfigParser()
  31.             config.readfp(file('/usr/share/python/debian_defaults'))
  32.             _defaults = config
  33.         else:
  34.             raise ValueError
  35.     os.path.exists('/usr/share/python/debian_defaults')
  36.     if _defaults and name:
  37.         
  38.         try:
  39.             value = _defaults.get('DEFAULT', name)
  40.         except NoOptionError:
  41.             raise ValueError
  42.  
  43.         return value
  44.  
  45.  
  46. def parse_versions(vstring, add_exact = False):
  47.     if vstring.lower().startswith('python:versions='):
  48.         vstring = string.split(vstring, '=', maxsplit = 1)[1]
  49.     
  50.     import operator as operator
  51.     operators = {
  52.         None: operator.eq,
  53.         '=': operator.eq,
  54.         '>=': operator.ge,
  55.         '<=': operator.le,
  56.         '<<': operator.lt }
  57.     vinfo = { }
  58.     exact_versions = set([])
  59.     version_range = set(supported_versions(version_only = True) + old_versions(version_only = True))
  60.     relop_seen = False
  61.     for field in vstring.split(','):
  62.         field = field.strip()
  63.         if field == 'all':
  64.             vinfo['all'] = 'all'
  65.             continue
  66.         
  67.         if field in ('current', 'current_ext'):
  68.             vinfo['current'] = field
  69.             continue
  70.         
  71.         vinfo.setdefault('versions', set())
  72.         ve = re.compile('(>=|<=|<<|=)? *(\\d\\.\\d)$')
  73.         m = ve.match(field)
  74.         
  75.         try:
  76.             op = m.group(1)
  77.             v = m.group(2)
  78.             if op in (None, '='):
  79.                 exact_versions.add(v)
  80.             else:
  81.                 relop_seen = True
  82.                 filtop = operators[op]
  83.                 version_range = _[1]
  84.         continue
  85.         except Exception:
  86.             raise ValueError, 'error parsing Python-Version attribute'
  87.             continue
  88.         
  89.  
  90.     
  91.     if add_exact:
  92.         if exact_versions:
  93.             vinfo['vexact'] = exact_versions
  94.         
  95.         if 'versions' in vinfo:
  96.             if relop_seen:
  97.                 vinfo['versions'] = set(version_range)
  98.             else:
  99.                 del vinfo['versions']
  100.         
  101.     elif 'versions' in vinfo:
  102.         vinfo['versions'] = exact_versions
  103.         if relop_seen:
  104.             vinfo['versions'] = exact_versions.union(version_range)
  105.         
  106.     
  107.     return vinfo
  108.  
  109. _old_versions = None
  110.  
  111. def old_versions(version_only = False):
  112.     global _old_versions
  113.     if not _old_versions:
  114.         
  115.         try:
  116.             value = read_default('old-versions')
  117.             _old_versions = [ s.strip() for s in value.split(',') ]
  118.         except ValueError:
  119.             _old_versions = []
  120.         except:
  121.             None<EXCEPTION MATCH>ValueError
  122.         
  123.  
  124.     None<EXCEPTION MATCH>ValueError
  125.     if version_only:
  126.         return [ v[6:] for v in _old_versions ]
  127.     return _old_versions
  128.  
  129. _unsupported_versions = None
  130.  
  131. def unsupported_versions(version_only = False):
  132.     global _unsupported_versions
  133.     if not _unsupported_versions:
  134.         
  135.         try:
  136.             value = read_default('unsupported-versions')
  137.             _unsupported_versions = [ s.strip() for s in value.split(',') ]
  138.         except ValueError:
  139.             _unsupported_versions = []
  140.         except:
  141.             None<EXCEPTION MATCH>ValueError
  142.         
  143.  
  144.     None<EXCEPTION MATCH>ValueError
  145.     if version_only:
  146.         return [ v[6:] for v in _unsupported_versions ]
  147.     return _unsupported_versions
  148.  
  149. _supported_versions = None
  150.  
  151. def supported_versions(version_only = False):
  152.     global _supported_versions
  153.     if not _supported_versions:
  154.         
  155.         try:
  156.             value = read_default('supported-versions')
  157.             _supported_versions = [ s.strip() for s in value.split(',') ]
  158.         except ValueError:
  159.             cmd = [
  160.                 '/usr/bin/apt-cache',
  161.                 '--no-all-versions',
  162.                 'show',
  163.                 'python-all']
  164.             
  165.             try:
  166.                 import subprocess as subprocess
  167.                 p = subprocess.Popen(cmd, bufsize = 1, shell = False, stdout = subprocess.PIPE)
  168.                 fd = p.stdout
  169.             except ImportError:
  170.                 fd = os.popen(' '.join(cmd))
  171.  
  172.             depends = None
  173.             for line in fd:
  174.                 if line.startswith('Depends:'):
  175.                     depends = line.split(':', 1)[1].strip().split(',')
  176.                     continue
  177.             
  178.             fd.close()
  179.             if not _supported_versions:
  180.                 _supported_versions = [
  181.                     'python2.4',
  182.                     'python2.5']
  183.             
  184.         except:
  185.             _supported_versions
  186.         
  187.  
  188.     None if depends else []
  189.     if version_only:
  190.         return [ v[6:] for v in _supported_versions ]
  191.     return _supported_versions
  192.  
  193. _default_version = None
  194.  
  195. def default_version(version_only = False):
  196.     global _default_version
  197.     if not _default_version:
  198.         
  199.         try:
  200.             _default_version = link = os.readlink('/usr/bin/python')
  201.         except OSError:
  202.             _default_version = None
  203.             
  204.             try:
  205.                 cmd = [
  206.                     '/usr/bin/python',
  207.                     '-c',
  208.                     'import sys; print sys.version[:3]']
  209.                 import subprocess
  210.                 p = subprocess.Popen(cmd, bufsize = 1, shell = False, stdout = subprocess.PIPE)
  211.                 fd = p.stdout
  212.             except ImportError:
  213.                 fd = os.popen("/usr/bin/python -c 'import sys; print sys.version[:3]'")
  214.  
  215.             line = fd.readline().strip()
  216.             fd.close()
  217.             if re.match('\\d\\.\\d$', line):
  218.                 _default_version = 'python' + line
  219.             
  220.         except:
  221.             re.match('\\d\\.\\d$', line)
  222.  
  223.         
  224.         try:
  225.             debian_default = read_default('default-version')
  226.         except ValueError:
  227.             debian_default = 'python2.5'
  228.  
  229.         if _default_version not in (debian_default, os.path.join('/usr/bin', debian_default)):
  230.             raise ValueError, '/usr/bin/python does not match the python default version. It must be reset to point to %s' % debian_default
  231.         _default_version not in (debian_default, os.path.join('/usr/bin', debian_default))
  232.         _default_version = debian_default
  233.     
  234.     if version_only:
  235.         return _default_version[6:]
  236.     return _default_version
  237.  
  238.  
  239. def requested_versions(vstring, version_only = False):
  240.     versions = None
  241.     vinfo = parse_versions(vstring, add_exact = True)
  242.     supported = supported_versions(version_only = True)
  243.     if len(vinfo) == 1:
  244.         if 'all' in vinfo:
  245.             versions = supported
  246.         elif 'current' in vinfo:
  247.             versions = [
  248.                 default_version(version_only = True)]
  249.         elif 'vexact' in vinfo:
  250.             versions = vinfo['vexact']
  251.         else:
  252.             versions = vinfo['versions'].intersection(supported)
  253.     elif 'all' in vinfo and 'current' in vinfo:
  254.         raise ValueError, "both `current' and `all' in version string"
  255.     elif 'all' in vinfo:
  256.         if 'versions' in vinfo:
  257.             versions = vinfo['versions'].intersection(supported)
  258.         else:
  259.             versions = set(supported)
  260.         if 'vexact' in vinfo:
  261.             versions.update(vinfo['vexact'])
  262.         
  263.     elif 'current' in vinfo:
  264.         current = default_version(version_only = True)
  265.         if current not in vinfo['versions']:
  266.             raise ValueError, "`current' version not in supported versions"
  267.         current not in vinfo['versions']
  268.         versions = [
  269.             current]
  270.     elif 'versions' in vinfo or 'vexact' in vinfo:
  271.         versions = set()
  272.         if 'versions' in vinfo:
  273.             versions = vinfo['versions'].intersection(supported)
  274.         
  275.         if 'vexact' in vinfo:
  276.             versions.update(vinfo['vexact'])
  277.         
  278.     else:
  279.         raise ValueError, 'error in version string'
  280.     if not 'vexact' in vinfo:
  281.         raise PyCentralEmptyValueError, 'empty set of versions'
  282.     'vexact' in vinfo
  283.     if version_only:
  284.         return versions
  285.     return [ 'python%s' % v for v in versions ]
  286.  
  287.  
  288. def requested_versions_for_runtime(vstring, version_only = False):
  289.     versions = None
  290.     vinfo = parse_versions(vstring, add_exact = True)
  291.     old = old_versions(version_only = True)
  292.     unsupported = unsupported_versions(version_only = True)
  293.     supported = supported_versions(version_only = True)
  294.     supported.extend(old)
  295.     if len(vinfo) == 1:
  296.         if 'all' in vinfo:
  297.             versions = supported
  298.         elif 'current' in vinfo:
  299.             versions = [
  300.                 default_version(version_only = True)]
  301.         elif 'vexact' in vinfo:
  302.             versions = vinfo['vexact']
  303.         else:
  304.             versions = vinfo['versions'].intersection(supported)
  305.     elif 'all' in vinfo and 'current' in vinfo:
  306.         raise ValueError, "both `current' and `all' in version string"
  307.     elif 'all' in vinfo:
  308.         if 'versions' in vinfo:
  309.             versions = vinfo['versions'].intersection(supported)
  310.         else:
  311.             versions = set(supported)
  312.         if 'vexact' in vinfo:
  313.             versions.update(vinfo['vexact'])
  314.         
  315.     elif 'current' in vinfo:
  316.         current = default_version(version_only = True)
  317.         if current not in vinfo['versions']:
  318.             raise ValueError, "`current' version not in supported versions"
  319.         current not in vinfo['versions']
  320.         versions = [
  321.             current]
  322.     elif 'versions' in vinfo or 'vexact' in vinfo:
  323.         versions = set()
  324.         if 'versions' in vinfo:
  325.             versions = vinfo['versions'].intersection(supported)
  326.         
  327.         if 'vexact' in vinfo:
  328.             versions.update(vinfo['vexact'])
  329.         
  330.     else:
  331.         raise ValueError, 'error in version string'
  332.     if not 'vexact' in vinfo:
  333.         raise PyCentralEmptyValueError, 'empty set of versions'
  334.     'vexact' in vinfo
  335.     if version_only:
  336.         return versions
  337.     return [ 'python%s' % v for v in versions ]
  338.  
  339.  
  340. def installed_versions(version_only = False):
  341.     import glob as glob
  342.     supported = supported_versions()
  343.     versions = _[1]
  344.     versions.sort()
  345.     if version_only:
  346.         return [ v[6:] for v in versions ]
  347.     return versions
  348.  
  349.  
  350. class ControlFileValueError(ValueError):
  351.     pass
  352.  
  353.  
  354. class MissingVersionValueError(ValueError):
  355.     pass
  356.  
  357.  
  358. def extract_pyversion_attribute(fn, pkg):
  359.     '''read the debian/control file, extract the XS-Python-Version
  360.     field; check that XB-Python-Version exists for the package.'''
  361.     version = None
  362.     sversion = None
  363.     section = None
  364.     for line in file(fn):
  365.         line = line.strip()
  366.         if line == '':
  367.             if section == None:
  368.                 continue
  369.             
  370.             if pkg == 'Source':
  371.                 break
  372.             
  373.             section = None
  374.             continue
  375.         if line.startswith('Source:'):
  376.             section = 'Source'
  377.             continue
  378.         if line.startswith('Package: ' + pkg):
  379.             section = pkg
  380.             continue
  381.         None if line.startswith('XS-Python-Version:') else section == pkg
  382.     
  383.     if section == None:
  384.         raise ControlFileValueError, 'not a control file'
  385.     section == None
  386.     if pkg == 'Source':
  387.         if sversion == None:
  388.             raise MissingVersionValueError, 'missing XS-Python-Version in control file'
  389.         sversion == None
  390.         return sversion
  391.     if version == None:
  392.         raise MissingVersionValueError, 'missing XB-Python-Version for package `%s' % pkg
  393.     version == None
  394.     return version
  395.  
  396.  
  397. def version_cmp(ver1, ver2):
  398.     v1 = [ int(i) for i in ver1.split('.') ]
  399.     v2 = [ int(i) for i in ver2.split('.') ]
  400.     return cmp(v1, v2)
  401.  
  402.  
  403. def requested_versions_bis(vstring, version_only = False):
  404.     versions = []
  405.     py_supported_short = supported_versions(version_only = True)
  406.     for item in vstring.split(','):
  407.         v = item.split('-')
  408.         if len(v) > 1:
  409.             if not v[0]:
  410.                 v[0] = py_supported_short[0]
  411.             
  412.             if not v[1]:
  413.                 v[1] = py_supported_short[-1]
  414.             
  415.             for ver in py_supported_short:
  416.                 
  417.                 try:
  418.                     if version_cmp(ver, v[0]) >= 0 and version_cmp(ver, v[1]) <= 0:
  419.                         versions.append(ver)
  420.                 continue
  421.                 except ValueError:
  422.                     continue
  423.                 
  424.  
  425.             
  426.         None<EXCEPTION MATCH>ValueError
  427.         if v[0] in py_supported_short:
  428.             versions.append(v[0])
  429.             continue
  430.     
  431.     versions.sort(version_cmp)
  432.     if not versions:
  433.         raise ValueError, 'empty set of versions'
  434.     versions
  435.     return versions
  436.  
  437.  
  438. def extract_pyversion_attribute_bis(fn):
  439.     vstring = file(fn).readline().rstrip('\n')
  440.     return vstring
  441.  
  442.  
  443. def main():
  444.     OptionParser = OptionParser
  445.     import optparse
  446.     usage = '[-v] [-h] [-d|--default] [-s|--supported] [-i|--installed] [-r|--requested <version string>|<control file>]'
  447.     parser = OptionParser(usage = usage)
  448.     parser.add_option('-d', '--default', help = 'print the default python version', action = 'store_true', dest = 'default')
  449.     parser.add_option('-s', '--supported', help = 'print the supported python versions', action = 'store_true', dest = 'supported')
  450.     parser.add_option('-r', '--requested', help = 'print the python versions requested by a build; the argument is either the name of a control file or the value of the XS-Python-Version attribute', action = 'store_true', dest = 'requested')
  451.     parser.add_option('-i', '--installed', help = 'print the installed supported python versions', action = 'store_true', dest = 'installed')
  452.     parser.add_option('-v', '--version', help = 'print just the version number(s)', default = False, action = 'store_true', dest = 'version_only')
  453.     (opts, args) = parser.parse_args()
  454.     program = os.path.basename(sys.argv[0])
  455.     if opts.default and len(args) == 0:
  456.         
  457.         try:
  458.             print default_version(opts.version_only)
  459.         except ValueError:
  460.             msg = None
  461.             print '%s:' % program, msg
  462.             sys.exit(1)
  463.         except:
  464.             None<EXCEPTION MATCH>ValueError
  465.         
  466.  
  467.     None<EXCEPTION MATCH>ValueError
  468.     if opts.supported and len(args) == 0:
  469.         print ' '.join(supported_versions(opts.version_only))
  470.     elif opts.installed and len(args) == 0:
  471.         print ' '.join(installed_versions(opts.version_only))
  472.     elif opts.requested and len(args) <= 1:
  473.         if len(args) == 0:
  474.             versions = 'debian/control'
  475.         else:
  476.             versions = args[0]
  477.         
  478.         try:
  479.             if os.path.isfile(versions):
  480.                 fn = versions
  481.                 
  482.                 try:
  483.                     vstring = extract_pyversion_attribute(fn, 'Source')
  484.                     vs = requested_versions(vstring, opts.version_only)
  485.                 except ControlFileValueError:
  486.                     sys.stderr.write('%s: not a control file: %s, ' % (program, fn))
  487.                     sys.exit(1)
  488.                 except MissingVersionValueError:
  489.                     fn = os.path.join(os.path.dirname(fn), 'pyversions')
  490.                     sys.stderr.write('%s: missing XS-Python-Version in control file, fall back to %s\n' % (program, fn))
  491.                     
  492.                     try:
  493.                         vstring = extract_pyversion_attribute_bis(fn)
  494.                         vs = requested_versions_bis(vstring, opts.version_only)
  495.                     except IOError:
  496.                         sys.stderr.write('%s: missing debian/pyversions file, fall back to supported versions\n' % program)
  497.                         vs = supported_versions(opts.version_only)
  498.                     except:
  499.                         None<EXCEPTION MATCH>IOError
  500.                     
  501.  
  502.                     None<EXCEPTION MATCH>IOError
  503.                 
  504.  
  505.             None<EXCEPTION MATCH>ControlFileValueError
  506.             vs = requested_versions(versions, opts.version_only)
  507.             print ' '.join(vs)
  508.         except ValueError:
  509.             msg = None
  510.             sys.stderr.write('%s: %s\n' % (program, msg))
  511.             sys.exit(1)
  512.         except:
  513.             None<EXCEPTION MATCH>ValueError
  514.         
  515.  
  516.     None<EXCEPTION MATCH>ValueError
  517.     sys.stderr.write('usage: %s %s\n' % (program, usage))
  518.     sys.exit(1)
  519.  
  520. if __name__ == '__main__':
  521.     main()
  522.  
  523.